package com.example.websocket_demo.service.user_relation;

import com.example.websocket_demo.dao.user.UserDao;
import com.example.websocket_demo.dao.user_apply_friend.UserApplyFriendDao;
import com.example.websocket_demo.dao.user_group.UserGroupDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class UserRelationServiceImpl implements UserRelationService{
    @Autowired
    private UserDao userDao;
    @Autowired
    private UserApplyFriendDao userApplyFriendDao;
    @Autowired
    private UserGroupDao userGroupDao;
    /*
     * 申请好友之前查询用户
     * 假设当前用户为A，A申请加B为好友
     * 搜索用户（根据B的邮箱号）
     *   1.查询用户表 user（根据B的邮箱号）
     *       - 没有，则返回（提示没有该用户）
     *       - 有，则下一步
     *   2.查询申请表 user_apply_friend（根据当前申请人A+被申请用户B+dr=0查询）
     *       - 有，则读取状态 result（待B验证0，已添加1）,返回（提示待B验证）
     *       - 没有，则下一步
     *   3.反过来查询申请表 user_apply_friend（当前申请人B+被申请用户A+dr=0查询）
     *       - 有，则读取状态 result（待A验证0，已添加1）
     *           - 待验证0（表明待A验证）,返回（提示待A验证）
     *           - 已添加1（该状态不可能出现，因为AB添加成功我会添加一条记录到 user_apply_friend，所以不会有反查的机会）
     *       - 没有，则下一步
     *   4.没有申请过，返回（是否创建一条新的记录到 user_apply_friend，当前申请人A+被申请用户B）
     * */
    @Override
    public Map<String, Object> selectUserBeforeApplyFriend(Integer userId, String friendEmail) {
        Map res=new HashMap();
        //1.查询用户表 user（根据B的邮箱号）
        List<Map<String,Object>> listUser= userDao.selectUser(new HashMap<String, Object>(){{
            put("email",friendEmail);
        }});
        if(listUser.size()==0){//没有改用户
            res.put("status",1);
            res.put("msg","没有该用户");
            return res;
        }
        //2.查询申请表 user_apply_friend（根据当前申请人A+被申请用户B+dr=0查询）
        Integer friendId = (Integer)listUser.get(0).get("id");
        List<Map<String,Object>> listApplyFriendUToF=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("user_id",userId);
            put("friend_id",friendId);
            put("dr",0);
        }});
        if(listApplyFriendUToF.size()!=0){//读取状态 result（待B验证0，已添加1）,返回（提示待B验证）
            Integer result = (Integer)listApplyFriendUToF.get(0).get("result");
            if(result==0){
                res.put("status",2);
                res.put("msg","待对方验证");
            }else if(result==1){
                res.put("status",3);
                res.put("msg","已添加");
            }
            res.put("friendUserInfo",listUser.get(0));
            return res;
        }
        //3.反过来查询申请表 user_apply_friend（当前申请人B+被申请用户A+dr=0查询）
        List<Map<String,Object>> listApplyFriendFToU=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("user_id",friendId);//反过来
            put("friend_id",userId);//反过来
            put("dr",0);
        }});
        if(listApplyFriendFToU.size()!=0){//读取状态 result（待B验证0，已添加1）,返回（提示待B验证）
            Integer result = (Integer)listApplyFriendFToU.get(0).get("result");
            if(result==0){
                res.put("status",4);
                res.put("msg","待自己同意");
            }else if(result==1){
                res.put("status",5);
                res.put("msg","已添加");
            }
            res.put("friendUserInfo",listUser.get(0));
            return res;
        }
        //4.没有申请过，返回
        res.put("status",6);
        res.put("msg","没有关系");
        res.put("friendUserInfo",listUser.get(0));
        return res;
    }
    /*
     * 1.根据用户id查询用户所有分组
     * */
    @Override
    public List<Map<String, Object>> selectUserGroupInfo(Integer userId) {
        return userGroupDao.selectUserGroup(new HashMap<String, Object>(){{
            put("user_id",userId);
        }});
    }
    /*
     * 2.添加分组
     * */
    @Override
    public Map<String, Object> addUserGroupInfo(Integer userId, String groupName) {
        return new HashMap<String, Object>(){{
            put("msg","插入UserGroup表");
            put("status",userGroupDao.insertUserGroup(new HashMap<String, Object>(){{
                put("user_id",userId);
                put("group_name",groupName);
            }}));
        }};
    }
    /*
     * 步骤三：------------------------------------------------------------------------------
     * 创建一条新的记录到user_apply_friend，当前申请人A+被申请用户B
     * 传参{
     *   user_id:userId,
     *   verification_info:verificationInfo,
     *   group_id:groupId,
     *   friend_id:friendId,
     *   remark:remark
     * }
     * */
    @Override
    public Map<String, Object> addApplyFriendInfo(Map<String, Object> map) {
        return new HashMap<String, Object>(){{
            put("msg","插入UserApplyFriend表");
            put("status",userApplyFriendDao.insertApplyFriend(map));
        }};
    }
    /*
     * 步骤四：------------------------------------------------------------------------------
     * 新朋友页面查询
     * A的userid
     * 查询多种情况
     *     待验证添加好友（待A验证，待对方验证）
     *     同意添加好友（已同意）
     *     拒绝添加好友（A拒绝，对方拒绝）
     * */
    @Override
    public Map<String, Object> selectNewFriendPageData(Integer userId) {
        //待对方验证
        List<Map<String,Object>> list1=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("user_id",userId);
            put("result",0);//待验证
            put("dr",0);
        }});
        //待自己验证
        List<Map<String,Object>> list2=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("friend_id",userId);
            put("result",0);//待验证
            put("dr",0);
        }});
        //已同意（好友请求是双向表）
        List<Map<String,Object>> list3=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("user_id",userId);
            put("result",1);//已同意
            put("dr",0);
        }});
        //自己拒绝的
        List<Map<String,Object>> list4=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("friend_id",userId);
            put("result",2);//拒绝的
            put("dr",1);
        }});
        //对方拒绝的
        List<Map<String,Object>> list5=userApplyFriendDao.selectApplyFriend(new HashMap<String, Object>(){{
            put("user_id",userId);
            put("result",2);//拒绝的
            put("dr",1);
        }});
        addUserInfoToList(list1);
        addUserInfoToList(list2);
        addUserInfoToList(list3);
        addUserInfoToList(list4);
        addUserInfoToList(list5);
        return new HashMap<String, Object>(){{
            put("list1",list1);//待对方验证
            put("list2",list2);//待自己验证
            put("list3",list3);//已同意（好友请求是双向表）
            put("list4",list4);//自己拒绝的
            put("list5",list5);//对方拒绝的
        }};
    }
    public void addUserInfoToList(List<Map<String,Object>> list){
        for(Map<String,Object> i:list){
            i.put("userInfo",userDao.selectUser(new HashMap<String, Object>(){{
                put("id",i.get("user_id"));
            }}).get(0));
            i.put("userFriendInfo",userDao.selectUser(new HashMap<String, Object>(){{
                put("id",i.get("friend_id"));
            }}).get(0));
        }
    }
}
